package org.teach.study.aigo.ai_go;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.quincy.rock.core.util.StringUtil;

public class StudyAlgorithm {

	public static void findPrime1() {//找出素數  最笨的办法

		int primenum = 0;
		for (int count = 1; count < 101; count++) {
			boolean flag = true;

			//从二开始，一旦出现能整除的，就表示不是素数，如果从二开始到她本身之前都没有整除的，
			//说明就是素数，这一解法从数组本身的定义出发的。
			for (int i = 2; i < count; i++) {
				if (count % i == 0) {
					flag = false;
					break;
				}
			} //內层循环结束
			if (flag == true) {
				System.out.print(count + ",");
				primenum++;
			}

		} //外层循环结束

		System.out.println("\n一共有" + primenum + "个素数");

	}

	public static List<Integer> findPrime2(int n) {//找出素数，聪明的办法
		int primenum = 0;
		List<Integer> retlist = new ArrayList<Integer>();
		//其实只要把循环一直从2尝试到根号x就可以，不难发现，一个数的两个因数中，必然有一个小于等于根号x，一个大于等于根号x，
		//例如100的因数有：1和100，2和50，4和25，5和20，10和10.所以只要从2尝试到根号x，
		//如果都没有被整除，就是素数，否则就不是。
		for (int count = 1; count < n; count++) {
			boolean flag = true;
			for (int i = 2; i <= Math.sqrt(count); i++) {
				if (count % i == 0) {
					flag = false;
					break;
				}

			} //内层结束
			if (flag == true) {
				//				System.out.print(count+",");
				retlist.add(count);
				primenum++;
			}

		} //外层结束
		System.out.println("一共有" + primenum + "个素数");
		return retlist;
	}

	public static void findPrimeT() {//找出素数，老师演示办法

		for (int i = 2; i < 100; i++) {
			boolean isPrime = true;
			for (int j = 2; j < i; j++) {
				int mod = i % j;
				if (mod == 0) {
					isPrime = false;
					break;
				}

			}
			if (isPrime) {
				System.out.print(i + ",");
			}

		}
	}

	public static int mysum(int n) {//从1加到100
		int mysum = 0;//存放从1加到100

		for (int i = 1; i <= n; i++) {//每次需要加的值
			mysum += i;
		} //循环结束

		return mysum;
	}

	public static int[] reverse(int arr[]) {//反转了，原来你也玩原神
		//老师的方法2
		int n = arr.length;
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[n - i - 1];
			arr[n - i - 1] = temp;
		}
		return arr;
	}

	public static int[] reverseT1(int[] arr) {//老师的方法1
		int[] arr2 = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			arr2[i] = arr[arr.length - i - 1];
		}
		return arr2;
	}

	/**
	 * <b>printYangHui。</b>
	 * <p><b>详细说明</b></p>
	 * <!-- 杨辉三角 -->
	 * 无。
	 * @param row 打印行数
	 */
	public static void printYangHui(int row) {
		int[][] arr = new int[row][row];//创建二维数组

		for (int i = 0; i < row; i++) {
			for (int j = 0; j <= i; j++) {//每行数字数量等于行数
				if (j == i || j == 0) {//首尾都是1
					arr[i][j] = 1;//两边边界值为0；
				} else {
					arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];//每行的下一位等于上面两位的和
				}

			}
		} //二维数组创建成功

		for (int i = 0; i < row; i++) {//输出二维数组，sout
			System.out.print(StringUtils.repeat(" ", row - i - 1));//生成每行前面的空白，repeat函数生成重复字符串
			for (int j = 0; j <= i; j++) {
				System.out.print(arr[i][j] + " ");//每个数字之后带个空格
			}
			System.out.println();//i之后换行
		}

	}

	/**
	 * <b>printDiamond1。</b>
	 * <p><b>详细说明：</b></p>
	 * <!-- 打印菱形 -->
	 * 无。
	 */
	public static void printDiamond1(int size) {
		//分两部分打，先打上部分，再打下部分
		if (size % 2 == 0) {
			size++; //  计算菱形大小  
		}

		// 打印菱形上半部分
		for (int i = 0; i < size / 2 + 1; i++) {//逐行打印
			/*for   ( int   j  =  size  /  2  +  1 ;  j  >  i  +  1 ;  j -- )   {//打印空白
			    System . out . print ( "   " ) ;  //  输出左上角位置的空白  
			}*/
			//System.out.print(StringUtils.repeat(" ", size-i-1));//生成每行前面的空白，repeat函数生成重复字符串,空白数量递减
			System.out.print(StringUtils.repeat(" ", size / 2 - i));
			for (int j = 0; j < 2 * i + 1; j++) {
				System.out.print("*"); //  输出菱形上半部边缘  
			}
			System.out.println(); //  换行  
		}

		// 打印菱形下半部分
		for (int i = size / 2 + 1; i < size; i++) {
			/*for   ( int   j  =  0 ;  j  <  i  -  size  /  2 ;  j ++ )   {
			    System . out . print ( "   " ) ;  //  输出菱形左下角空白  
			}*/
			
			//	System.out.print(StringUtils.repeat(" ", i));//生成每行前面的空白，repeat函数生成重复字符串,空白数量递增
			int n=i - size / 2;//空格数量
			System.out.print(StringUtils.repeat(" ",n));//生成每行前面的空白，repeat函数生成重复字符串，空白数量递增
			for (int j = 0; j < 2 * size - 1 - 2 * i; j++) {
				System.out.print("*"); //  输出菱形下半部边缘  
			}
			System.out.println(); //  换行  
		}
	}

	
	/**
	 * <b>bubbleSort。</b>
	 * <p><b>详细说明：</b></p>
	 * <!-- 冒泡排序 -->
	 * 无。
	 */
	public static void bubbleSort(int[] sourceArray) {
		 // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
        for (int i = 1; i < arr.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换相邻两个元素的位置
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    // 设置标记为false，表示发生了交换
                    flag = false;
                }
            }

            // 如果待排序列已经有序，即没有发生交换，则跳出循环，排序已完成
            if (flag) {
                break;
            }
        }

        System.out.println(Arrays.toString(arr));

    }
	
}
